package com.hifar.utils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Pattern;

/**
 * 日期解析工具类
 * 支持多种日期格式的智能解析
 * 
 * @author system
 * @date 2025-01-XX
 */
public class DateParseUtil {
    
    /**
     * 智能日期解析
     * 支持多种日期格式的自动识别和解析
     * 
     * @param dateStr 日期字符串
     * @param formats 支持的日期格式数组
     * @return 解析后的Date对象，解析失败返回null
     */
    public static Date smartParseDate(String dateStr, String[] formats) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return null;
        }
        
        dateStr = dateStr.trim();
        
        // 如果为空字符串，返回null
        if (dateStr.isEmpty()) {
            return null;
        }
        
        // 尝试使用指定的格式进行解析
        for (String format : formats) {
            try {
                SimpleDateFormat sdf = new SimpleDateFormat(format);
                sdf.setLenient(false); // 严格模式
                Date date = sdf.parse(dateStr);
                // 验证解析结果是否正确（防止误解析）
                if (isValidDate(date, dateStr, format)) {
                    return date;
                }
            } catch (ParseException e) {
                // 继续尝试下一个格式
                continue;
            }
        }
        
        // 如果所有格式都失败，尝试智能解析
        return smartParseDate(dateStr);
    }
    
    /**
     * 智能日期解析（使用默认格式）
     * 
     * @param dateStr 日期字符串
     * @return 解析后的Date对象，解析失败返回null
     */
    public static Date smartParseDate(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return null;
        }
        
        dateStr = dateStr.trim();
        
        // 默认支持的日期格式
        String[] defaultFormats = {
            "yyyy-MM-dd",
            "yyyy/MM/dd", 
            "yyyy.MM.dd",
            "yyyy年MM月dd日",
            "MM/dd/yyyy",
            "dd/MM/yyyy",
            "yyyy-M-d",
            "yyyy/M/d",
            "yyyy.M.d",
            "yyyy年M月d日",
            "M/d/yyyy",
            "d/M/yyyy",
            "d-M-yyyy",
            "yyyyMMdd",
            "MMdd",
            "yyyy-MM-dd HH:mm:ss",
            "yyyy/MM/dd HH:mm:ss",
            "yyyy.MM.dd HH:mm:ss",
            "yyyy年MM月dd日 HH:mm:ss",
            "HH:mm:ss",
            "HH:mm"
        };
        
        return smartParseDate(dateStr, defaultFormats);
    }
    
    /**
     * 使用多种格式解析日期（用逗号分隔的格式字符串）
     * 
     * @param dateStr 日期字符串
     * @param formatStr 格式字符串，多个格式用逗号分隔
     * @return 解析后的Date对象，解析失败返回null
     */
    public static Date parseDateWithFormats(String dateStr, String formatStr) {
        if (dateStr == null || dateStr.trim().isEmpty() || formatStr == null || formatStr.trim().isEmpty()) {
            return null;
        }
        
        String[] formats = formatStr.split(",");
        for (int i = 0; i < formats.length; i++) {
            formats[i] = formats[i].trim();
        }
        
        return smartParseDate(dateStr, formats);
    }
    
    /**
     * 验证解析的日期是否正确
     * 
     * @param date 解析后的日期
     * @param originalStr 原始字符串
     * @param format 使用的格式
     * @return 是否有效
     */
    private static boolean isValidDate(Date date, String originalStr, String format) {
        if (date == null) {
            return false;
        }
        
        try {
            // 对于某些格式，进行特殊验证
            if (format.contains("yyyy")) {
                // 验证年份是否合理
                java.util.Calendar cal = java.util.Calendar.getInstance();
                cal.setTime(date);
                String yearStr = String.valueOf(cal.get(java.util.Calendar.YEAR));
                if (!originalStr.contains(yearStr)) {
                    return false;
                }
            }
            
            // 对于短格式（如MMdd），需要特殊处理
            if (format.equals("MMdd")) {
                // 验证月份和日期是否合理
                java.util.Calendar cal = java.util.Calendar.getInstance();
                cal.setTime(date);
                int month = cal.get(java.util.Calendar.MONTH) + 1;
                int day = cal.get(java.util.Calendar.DAY_OF_MONTH);
                if (month < 1 || month > 12 || day < 1 || day > 31) {
                    return false;
                }
            }
            
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    
    
    /**
     * 检查字符串是否为数字格式的日期
     * 
     * @param dateStr 日期字符串
     * @return 是否为数字格式
     */
    public static boolean isNumericDate(String dateStr) {
        if (dateStr == null) {
            return false;
        }
        
        return Pattern.matches("\\d{4,8}", dateStr);
    }
    
    /**
     * 获取日期格式的优先级
     * 根据字符串特征判断最可能的日期格式
     * 
     * @param dateStr 日期字符串
     * @return 推荐的格式数组
     */
    public static String[] getRecommendedFormats(String dateStr) {
        if (dateStr == null) {
            return new String[0];
        }
        
        if (dateStr.contains("-")) {
            return new String[]{"yyyy-MM-dd", "yyyy-M-d", "yyyy-MM-dd HH:mm:ss"};
        } else if (dateStr.contains("/")) {
            return new String[]{"yyyy/MM/dd", "yyyy/M/d", "MM/dd/yyyy", "M/d/yyyy", "yyyy/MM/dd HH:mm:ss"};
        } else if (dateStr.contains(".")) {
            return new String[]{"yyyy.MM.dd", "yyyy.M.d", "yyyy.MM.dd HH:mm:ss"};
        } else if (dateStr.contains("年") && dateStr.contains("月") && dateStr.contains("日")) {
            return new String[]{"yyyy年MM月dd日", "yyyy年M月d日", "yyyy年MM月dd日 HH:mm:ss"};
        } else if (Pattern.matches("\\d{8}", dateStr)) {
            return new String[]{"yyyyMMdd"};
        } else if (Pattern.matches("\\d{6}", dateStr)) {
            return new String[]{"MMdd", "yyyyMM"};
        } else if (Pattern.matches("\\d{4}", dateStr)) {
            return new String[]{"MMdd", "yyyy"};
        }
        
        return new String[]{"yyyy-MM-dd", "yyyy/MM/dd", "yyyy.MM.dd"};
    }
}
